includable / cli

const util = require('../util')

const output = require('../output')

const helpers = require('../run-helpers')

const pkg = require('../../package.json')

const fs = require('fs')

const os = require('os')

const path = require('path')

const https = require('https')

const name = require('git-user-name')

const email = require('git-user-email')

const child = require('child_process')

const chalk = require('chalk')

const unzip = require('unzip-stream')

const rimraf = require('rimraf')

const jsonfile = require('jsonfile')

const mkdirp = require('mkdirp')

const compareVersions = require('compare-versions')

var Kit = {}

function extractZip (response, zipName, containerPath, callback, namespace, url) {

  // Create cache directory

  var tmpdir = path.join(os.tmpdir(), 'inc-v' + pkg.version, namespace)

  try {

    mkdirp.sync(tmpdir)

  } catch (e) {

    return callback(e)

  }

  return response

    .pipe(unzip.Extract({

      path: tmpdir

    }))

    .on('error', function (err) {

      callback(err)

    })

    .on('close', function () {

      setTimeout(function () {

        try {

          // At this point, there is a good possibility that all files got

          // extracted to a subdirectory, which we should correct

          var zipPath = path.join(tmpdir, zipName)

          if (!fs.existsSync(zipPath)) {

            callback(new Error('Error extracting zip file'))

            return

          }

          // Check requirements

          var json = jsonfile.readFileSync(path.join(zipPath, 'module.json'))

          var res = Kit.checkRequirements(json, namespace, url, zipPath)

          if (res !== true) {

            callback(res)

            rimraf.sync(zipPath)

            process.exit()

          }

          fs.renameSync(zipPath, path.resolve(containerPath))

          // Calling back home

          callback(null)

        } catch (e) {

          callback(e)

        }

      }, 500)

    })

}

function downloadZip (zipUrl, zipName, containerPath, callback, namespace, origUrl) {

  https.get(zipUrl, function (response) {

    if (response.statusCode >= 200 && response.statusCode < 300) {

      extractZip(response, zipName, containerPath, callback, namespace, origUrl || zipUrl)

      return

    }

    if (response.headers.location) {

      downloadZip(response.headers.location, zipName, containerPath, callback, namespace, zipUrl)

      return

    }

    callback(new Error(response.statusCode + ' ' + response.statusMessage))

  }).on('error', function (err) {

    callback(err)

  })

}

function postProcess (slug) {

  // Remove stock files

  try { fs.unlinkSync(path.join(slug, 'LICENSE.md')) } catch (e) {}

  try { fs.unlinkSync(path.join(slug, 'LICENSE')) } catch (e) {}

  try { fs.unlinkSync(path.join(slug, 'README')) } catch (e) {}

  try { rimraf.sync(path.join(slug, '.git')) } catch (e) {}

  // Write readme.md

  fs.writeFileSync(path.join(slug, 'README.md'), '# ' +

    util.boxNameDisplay(slug) + '\n\nA Incluable app for ' + util.boxNameDisplay(slug) + '.', 'utf8')

  // Download IDE helper

  var ideSpinner = output.wait('Downloading code completion helper')

  util.downloadHelper(function () {

    ideSpinner(true)

    // Git init

    var gitSpinner = output.wait('Initializing local Git repository')

    child.exec('cd "' + slug + '" && git init', function (err) {

      gitSpinner(err ? err : true)

      output.newline()

      output.success('To get started:')

      output.write('\n' + chalk.bold.magenta('  cd ' + slug) + chalk.gray(' to enter your new module\'s directory\n'))

      output.write(chalk.bold.magenta('  inc run') + chalk.gray(' to run your module in the browser\n\n\n'))

    })

  }, slug)

}

Kit.download = function (kitName, targetPath, callback) {

  var containerPath = path.resolve(targetPath)

  var kitNameResolved = this.resolveName(kitName)

  var namespace = kitNameResolved.split('/')[0]

  var kitNameSimplified = kitNameResolved.split('/')[1]

  var zipUrl = 'https://github.com/' + kitNameResolved + '/archive/master.zip'

  downloadZip(zipUrl, kitNameSimplified + '-master', containerPath, callback, namespace)

}

Kit.resolveName = function (kitName) {

  kitName = kitName.replace(/\s/ig, '')

  if (kitName.indexOf('/') > 0) {

    // Repo name already includes user/org, so skip any other processing

    return kitName

  }

  // Prepend 'starter-'

  if (kitName.indexOf('starter-') !== 0) {

    kitName = 'starter-' + kitName

  }

  // Prepend org name

  return 'includable-modules/' + kitName

}

Kit.checkRequirements = function (json, namespace, url, zipPath) {

  // If not exists, no need to check anything

  if (!('_starter' in json) || typeof json._starter !== 'object') {

    return true

  }

  // Check minimal CLI version to run this starter kit

  if ('minVersion' in json._starter && compareVersions(json._starter.minVersion, pkg.version) === 1) {

    return 'Starter kit requires version ' + json._starter.minVersion + ' of ' +

      'Includable CLI, but you have ' + pkg.version + '. Please update!'

  }

  // Save starter.json meta data

  mkdirp.sync(path.join(zipPath, '.inc', 'meta'))

  json._starter.sourceUrl = url

  json._starter.namespace = namespace

  jsonfile.writeFileSync(path.join(zipPath, '.inc', 'meta', 'starter.json'), json._starter)

  // Remove starter meta data

  delete json['_starter']

  return true

}

Kit.create = function (kitName, slug) {

  // Get slug

  var userName = (util.getSystemUsername() || 'user').toLowerCase()

  if (slug.match(/^[a-z0-9-]+\/[a-z0-9-]+$/)) {

    userName = slug.split('/')[0]

    slug = slug.split('/')[1]

  }

  if (!slug.match(/^[a-z0-9-]+$/)) {

    output.err('Module name should only contain lowercase letters, numbers and dashes.')

    return

  }

  // Check if directory doesn't already exist

  var stopSpinner = output.wait('Downloading template \'' + kitName + '\'')

  if (fs.existsSync(slug)) {

    stopSpinner('Directory \'' + slug + '\' already exists!')

    return

  }

  try {

    stopSpinner(e)

  }

}

module.exports = Kit